/**
 * The Entry class is a mean to log a key associated with its value.
 *
 * The Entry class is used by the EntryIterable class to obtain each entry to the map
 * and thus obtain each keys and values in a loop.
 *
 * @class Entry<K,V>
 * @version 1.2
 * @since 1.4
 */
declare abstract class Entry<K, V> {
    /**
     * Get the key of the map
     *
     * @returns {String[]} the keys of the map
     * @since 1.0
     */
    abstract getKey(): K;
    /**
     * Get the value of the map
     *
     * @return {Object[]} the value of the map
     * @since 1.0
     */
    abstract getValue(): V;
    /**
     * Check if the indexing return to the last position.
     *
     * @returns {boolean} return true if the indexing is placed to the last position.
     * @since 1.5
     */
    abstract isLastData(): boolean;
    /**
     * Check if the indexing return to the first position.
     *
     * @returns {boolean} return true is the indexing is placed to the first position.
     * @since 1.5
     */
    abstract isFirstData(): boolean;
}
/**
 * Public constants for type of inversement of the map.
 *
 * @class MapType
 * @version 1.0
 * @since 1.0
 */
export declare abstract class MapType {
    /**
     * Reverse only keys
     *
     * @constant TYPE_KEYS
     * @type {number}
     * @since 1.0
     */
    static TYPE_KEYS: number;
    /**
     * Reverse only values
     *
     * @constant TYPE_VALUES
     * @type {number}
     * @since 1.0
     */
    static TYPE_VALUES: number;
}
/**
 * The LinkedMap tool allows you to manipulate a map containing keys and values.
 *
 * LinkedMap is a way to create and manage a associative array.
 *
 * @class Map
 * @version 1.5
 * @since 1.0
 */
export declare abstract class Map {
    /**
     * Return the size of map
     *
     * @returns return the size of the map
     * @type {number}
     * @since 1.0
     */
    abstract length(): number;
    /**
     * Check if the value exists in the map
     *
     * @param value the specified value
     * @returns return true if the occurrence is existing in the map
     * @type {boolean}
     * @since 1.0
     */
    abstract contains(value: Object): boolean;
    /**
     * Return the key of the finded occurrence in the map
     *
     * @param value value whose the key in the map is to be finded
     * @returns return null if the map does not contain the occurrence
     * @type {String | null}
     * @since 1.2
     */
    abstract keyOf(value: Object): String | null;
    /**
     * Add a specific value and associates with the specified key in this map
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @type {void}
     * @throws MaximumCapacityException when you have reached the maximum capacity of elements that the map can contain
     * @throws IllegalArgumentException if the key is not a String type
     * @throws NullPointerException if the key is null or empty
     * @throws IllegalArgumentException if the key is already existing in the map
     * @since 1.5
     */
    abstract add(key: String, value: Object): void;
    /**
     * Add a specific value onnly if the value is not in the map and associates with the specified key in this map
     *
     * @todo This is use the default implementation of (#method Map.add)
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @type {void}
     * @throws MaximumCapacityException when you have reached the maximum capacity of elements that the map can contain
     * @throws IllegalArgumentException if the key is not a String type
     * @throws NullPointerException if the key is null or empty
     * @throws IllegalArgumentException if the key is already existing in the map
     * @since 1.5
     */
    abstract addIfAbsent(key: String, value: Object): void;
    /**
     * Add all datas of one map in the current map
     *
     * @todo This is use the default implementation of (#method Map.add)
     *
     * @param maps The newests maps to add
     * @type {void}
     * @throws ObjectCastException if the (#param maps) is not not an instance of LinkedMap
     * @throws MaximumCapacityException when you have reached the maximum capacity of elements that the map can contain
     * @throws IllegalArgumentException if the key is not a String type
     * @throws NullPointerException if the key is null or empty
     * @throws IllegalArgumentException if the key is already existing in the map
     * @since 1.5
     */
    abstract addAll(...maps: Map[]): void;
    /**
     * Get the value with the specified keys
     *
     * @param key key with which the specified value is to be associated
     * @returns return the added value specified by its key or return null if the key does not exist on the map
     * @type {Object | null}
     * @since 1.0
     */
    abstract get(key: String): Object | null;
    /**
     * Replace the value by the associated specified key in the map by the new specified value
     *
     * @param key key of value to replace
     * @param value value to be replaced at the place of specified associate key
     * @type {void}
     * @throws IllegalArgumentException if the key does not exist in the map
     * @since 1.5
     */
    abstract set(key: String, value: Object): void;
    /**
     * Remove the value with its associated specified key
     *
     * @param key key of value to remove
     * @type {void}
     * @throws IllegalArgumentException if the key does not exist in the map
     * @since 1.5
     */
    abstract remove(key: String): void;
    /**
     * Clear the map
     *
     * Remove all keys and values
     *
     * @type {void}
     * @since 1.2
     */
    abstract clear(): void;
    /**
     * Clear the map
     *
     * Remove all keys and values
     * To avoid memory leaks
     *
     * @type {void}
     * @since 1.0
     */
    abstract clearMemory(): void;
    /**
     * Check if the map is empty
     *
     * @return return true if the map is empty and return false if the map is not empty
     * @type {boolean}
     * @since 1.4
     */
    abstract isEmpty(): boolean;
    /**
     * Reiterate each entry of the map for obtain the values and keys
     *
     * @return return the entries iterable
     * @type {Iterable<Entry<String, Object>>}
     * @since 1.4
     */
    abstract entries(): Iterable<Entry<String, Object>>;
    /**
     * Reverse the map
     *
     * @param type Type of inversement
     * @type {void}
     * @todo (optional) You can try enter a type of inversement
     * @constant MapType.TYPE_KEYS
     * @constant MapType.TYPE_VALUES
     * @example map.reverse() map.reverse(MapType.TYPE_KEYS) map.revers(MapType.TYPE_VALUES)
     * @since 1.3
     */
    abstract reverse(type?: number): void;
    /**
     * Return the map to char string format
     *
     * @return return the map to char string format
     * @type {string}
     * @example
     * Syntax:
     * [
     *  "key1" => "value1",
     *  "key2" => "1",
     *  "key3" => "false",
     *  "key4" => "Object",
     *  "key5" => "1.2"
     * ]
     * @since 1.0
     */
    abstract toString(): string;
    /**
     * Return the map to JSON string format
     *
     * @return return the map to JSON format
     * @type {string}
     * @throws IllegalArgumentException if the map contain an object
     * @example
     * Syntax:
     * {
     *  "key1": "value1",
     *  "key2": 1,
     *  "key3": false,
     *  "key4": 1.2
     * }
     * @since 1.5
     */
    abstract toJSON(): string;
}
/**
 * The LinkedMap tool allows you to manipulate a map containing keys and values.
 *
 * LinkedMap is a way to create and manage a associative array.
 *
 * @class LinkedMap
 * @version 1.5
 * @since 1.0
 */
export declare class LinkedMap extends Map {
    private keys;
    private values;
    private size;
    private PREFIX_EXCEPTION;
    private MAXIMUM_CAPACITY;
    constructor();
    /**
     * Init a new object Map of your object.
     *
     * @param object Your primitive object.
     * @returns Return the newest map.
     * @type {Map}
     * @since 1.7
     */
    static fromObject(object: {}): Map;
    length(): number;
    contains(value: Object): boolean;
    keyOf(value: Object): String | null;
    add(key: String, value: Object): void;
    addIfAbsent(key: String, value: Object): void;
    addAll(...maps: Map[]): void;
    get(key: String): object | null;
    set(key: String, value: Object): void;
    remove(key: String): void;
    clear(): void;
    clearMemory(): void;
    isEmpty(): boolean;
    entries(): Iterable<Entry<String, Object>>;
    reverse(type?: number): void;
    toString(): string;
    toJSON(): string;
    /**
     * Ensures the incrementation of the size to update the current size of the map
     *
     * @param value incremented value
     * @type {void}
     * @since 1.0
     */
    private ensureIncrementSize;
    /**
     * Ensures the decrementation of the size to update the current size of the map
     *
     * @param value Decremented value
     * @type {void}
     * @since 1.0
     */
    private ensureDecrementSize;
    /**
     * Check if the key exist in the map and return the current index for get value
     *
     * @param key the key whose exist in the map is to be finded
     * @returns return the index of key
     * @type {number}
     * @since 1.0
     */
    private checkIfKeyExist;
    /**
     * Return the index of the finded occurrence in the map
     * return -1 if the map does not contain the occurrence
     *
     * @param value value whose exist in the map is to be finded
     * @returns return the index of values
     * @type {number}
     * @since 1.0
     */
    private indexOf;
}
export {};
//# sourceMappingURL=LinkedMap.d.ts.map